﻿using System;
using System.ComponentModel;
using System.IO;
using System.Runtime.Serialization;

namespace HalconDotNet
{
	/// <summary>Represents an instance of a SVM OCR classifier.</summary>
	// Token: 0x02000055 RID: 85
	[Serializable]
	public class HOCRSvm : HHandle, ISerializable, ICloneable
	{
		// Token: 0x06000C3A RID: 3130 RVA: 0x0000883B File Offset: 0x00006A3B
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRSvm() : base(HHandleBase.UNDEF)
		{
		}

		// Token: 0x06000C3B RID: 3131 RVA: 0x0004D45D File Offset: 0x0004B65D
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRSvm(IntPtr handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000C3C RID: 3132 RVA: 0x0004D46C File Offset: 0x0004B66C
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRSvm(HHandle handle) : base(handle)
		{
			this.AssertSemType();
		}

		// Token: 0x06000C3D RID: 3133 RVA: 0x0004D47B File Offset: 0x0004B67B
		private void AssertSemType()
		{
			base.AssertSemType("ocr_svm");
		}

		// Token: 0x06000C3E RID: 3134 RVA: 0x0004D488 File Offset: 0x0004B688
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HOCRSvm obj)
		{
			obj = new HOCRSvm(HHandleBase.UNDEF);
			return obj.Load(proc, parIndex, err);
		}

		// Token: 0x06000C3F RID: 3135 RVA: 0x0004D4A0 File Offset: 0x0004B6A0
		internal static int LoadNew(IntPtr proc, int parIndex, int err, out HOCRSvm[] obj)
		{
			HTuple htuple;
			err = HTuple.LoadNew(proc, parIndex, err, out htuple);
			obj = new HOCRSvm[htuple.Length];
			for (int i = 0; i < htuple.Length; i++)
			{
				obj[i] = new HOCRSvm(HalconAPI.IsLegacyHandleMode() ? htuple[i].IP : htuple[i].H);
			}
			htuple.Dispose();
			return err;
		}

		/// <summary>
		///   Read a SVM-based OCR classifier from a file.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C40 RID: 3136 RVA: 0x0004D510 File Offset: 0x0004B710
		public HOCRSvm(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(676);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a support vector machine.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="kernelType">The kernel type. Default: "rbf"</param>
		/// <param name="kernelParam">Additional parameter for the kernel function. Default: 0.02</param>
		/// <param name="nu">Regularization constant of the SVM. Default: 0.05</param>
		/// <param name="mode">The mode of the SVM. Default: "one-versus-one"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "normalization"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		// Token: 0x06000C41 RID: 3137 RVA: 0x0004D55C File Offset: 0x0004B75C
		public HOCRSvm(int widthCharacter, int heightCharacter, string interpolation, HTuple features, HTuple characters, string kernelType, double kernelParam, double nu, string mode, string preprocessing, int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(689);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.Store(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreS(proc, 5, kernelType);
			HalconAPI.StoreD(proc, 6, kernelParam);
			HalconAPI.StoreD(proc, 7, nu);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, preprocessing);
			HalconAPI.StoreI(proc, 10, numComponents);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a support vector machine.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="kernelType">The kernel type. Default: "rbf"</param>
		/// <param name="kernelParam">Additional parameter for the kernel function. Default: 0.02</param>
		/// <param name="nu">Regularization constant of the SVM. Default: 0.05</param>
		/// <param name="mode">The mode of the SVM. Default: "one-versus-one"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "normalization"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		// Token: 0x06000C42 RID: 3138 RVA: 0x0004D610 File Offset: 0x0004B810
		public HOCRSvm(int widthCharacter, int heightCharacter, string interpolation, string features, HTuple characters, string kernelType, double kernelParam, double nu, string mode, string preprocessing, int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(689);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.StoreS(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreS(proc, 5, kernelType);
			HalconAPI.StoreD(proc, 6, kernelParam);
			HalconAPI.StoreD(proc, 7, nu);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, preprocessing);
			HalconAPI.StoreI(proc, 10, numComponents);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		// Token: 0x06000C43 RID: 3139 RVA: 0x0004D6C0 File Offset: 0x0004B8C0
		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassSvm();
			byte[] value = hserializedItem;
			hserializedItem.Dispose();
			info.AddValue("data", value, typeof(byte[]));
		}

		// Token: 0x06000C44 RID: 3140 RVA: 0x0004D6F8 File Offset: 0x0004B8F8
		[EditorBrowsable(EditorBrowsableState.Never)]
		public HOCRSvm(SerializationInfo info, StreamingContext context)
		{
			HSerializedItem hserializedItem = new HSerializedItem((byte[])info.GetValue("data", typeof(byte[])));
			this.DeserializeOcrClassSvm(hserializedItem);
			hserializedItem.Dispose();
		}

		/// <summary>Serialize object to binary stream in HALCON format</summary>
		// Token: 0x06000C45 RID: 3141 RVA: 0x0004D738 File Offset: 0x0004B938
		public new void Serialize(Stream stream)
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassSvm();
			hserializedItem.Serialize(stream);
			hserializedItem.Dispose();
		}

		/// <summary>Deserialize object from binary stream in HALCON format</summary>
		// Token: 0x06000C46 RID: 3142 RVA: 0x0004D74C File Offset: 0x0004B94C
		public new static HOCRSvm Deserialize(Stream stream)
		{
			HOCRSvm hocrsvm = new HOCRSvm();
			HSerializedItem hserializedItem = HSerializedItem.Deserialize(stream);
			hocrsvm.DeserializeOcrClassSvm(hserializedItem);
			hserializedItem.Dispose();
			return hocrsvm;
		}

		// Token: 0x06000C47 RID: 3143 RVA: 0x0004D772 File Offset: 0x0004B972
		object ICloneable.Clone()
		{
			return this.Clone();
		}

		// Token: 0x06000C48 RID: 3144 RVA: 0x0004D77C File Offset: 0x0004B97C
		public new HOCRSvm Clone()
		{
			HSerializedItem hserializedItem = this.SerializeOcrClassSvm();
			HOCRSvm hocrsvm = new HOCRSvm();
			hocrsvm.DeserializeOcrClassSvm(hserializedItem);
			hserializedItem.Dispose();
			return hocrsvm;
		}

		/// <summary>
		///   Select an optimal combination of features to classify OCR data from a (protected) training file.
		///   Modified instance represents: Trained OCR-SVM Classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C49 RID: 3145 RVA: 0x0004D7A4 File Offset: 0x0004B9A4
		public HTuple SelectFeatureSetTrainfSvmProtected(HTuple trainingFile, HTuple password, HTuple featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(663);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, password);
			HalconAPI.Store(proc, 2, featureList);
			HalconAPI.StoreS(proc, 3, selectionMethod);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(password);
			HalconAPI.UnpinTuple(featureList);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Select an optimal combination of features to classify OCR data from a (protected) training file.
		///   Modified instance represents: Trained OCR-SVM Classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C4A RID: 3146 RVA: 0x0004D878 File Offset: 0x0004BA78
		public HTuple SelectFeatureSetTrainfSvmProtected(string trainingFile, string password, string featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(663);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, password);
			HalconAPI.StoreS(proc, 2, featureList);
			HalconAPI.StoreS(proc, 3, selectionMethod);
			HalconAPI.StoreI(proc, 4, width);
			HalconAPI.StoreI(proc, 5, height);
			HalconAPI.Store(proc, 6, genParamName);
			HalconAPI.Store(proc, 7, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selects an optimal combination of features to classify OCR  data.
		///   Modified instance represents: Trained OCR-SVM Classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C4B RID: 3147 RVA: 0x0004D938 File Offset: 0x0004BB38
		public HTuple SelectFeatureSetTrainfSvm(HTuple trainingFile, HTuple featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(664);
			HalconAPI.Store(proc, 0, trainingFile);
			HalconAPI.Store(proc, 1, featureList);
			HalconAPI.StoreS(proc, 2, selectionMethod);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(featureList);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Selects an optimal combination of features to classify OCR  data.
		///   Modified instance represents: Trained OCR-SVM Classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: ""</param>
		/// <param name="featureList">List of features that should be considered for selection. Default: ["zoom_factor","ratio","width","height","foreground","foreground_grid_9","foreground_grid_16","anisometry","compactness","convexity","moments_region_2nd_invar","moments_region_2nd_rel_invar","moments_region_3rd_invar","moments_central","phi","num_connect","num_holes","projection_horizontal","projection_vertical","projection_horizontal_invar","projection_vertical_invar","chord_histo","num_runs","pixel","pixel_invar","pixel_binary","gradient_8dir","cooc","moments_gray_plane"]</param>
		/// <param name="selectionMethod">Method to perform the selection. Default: "greedy"</param>
		/// <param name="width">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 15</param>
		/// <param name="height">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 16</param>
		/// <param name="genParamName">Names of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="genParamValue">Values of generic parameters to configure the selection process and the classifier. Default: []</param>
		/// <param name="score">Achieved score using tow-fold cross-validation.</param>
		/// <returns>Selected feature set, contains only entries from FeatureList.</returns>
		// Token: 0x06000C4C RID: 3148 RVA: 0x0004D9FC File Offset: 0x0004BBFC
		public HTuple SelectFeatureSetTrainfSvm(string trainingFile, string featureList, string selectionMethod, int width, int height, HTuple genParamName, HTuple genParamValue, out HTuple score)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(664);
			HalconAPI.StoreS(proc, 0, trainingFile);
			HalconAPI.StoreS(proc, 1, featureList);
			HalconAPI.StoreS(proc, 2, selectionMethod);
			HalconAPI.StoreI(proc, 3, width);
			HalconAPI.StoreI(proc, 4, height);
			HalconAPI.Store(proc, 5, genParamName);
			HalconAPI.Store(proc, 6, genParamValue);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(genParamName);
			HalconAPI.UnpinTuple(genParamValue);
			num = base.Load(proc, 0, num);
			HTuple result;
			num = HTuple.LoadNew(proc, 1, num, out result);
			num = HTuple.LoadNew(proc, 2, HTupleType.DOUBLE, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>Clear an SVM-based OCR classifier.</summary>
		/// <param name="OCRHandle">Handle of the OCR classifier.</param>
		// Token: 0x06000C4D RID: 3149 RVA: 0x0004DAB4 File Offset: 0x0004BCB4
		public static void ClearOcrClassSvm(HOCRSvm[] OCRHandle)
		{
			HTuple htuple = HHandleBase.ConcatArray(OCRHandle);
			IntPtr proc = HalconAPI.PreCall(673);
			HalconAPI.Store(proc, 0, htuple);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(htuple);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(OCRHandle);
		}

		/// <summary>
		///   Clear an SVM-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		// Token: 0x06000C4E RID: 3150 RVA: 0x0004DAF8 File Offset: 0x0004BCF8
		public void ClearOcrClassSvm()
		{
			IntPtr proc = HalconAPI.PreCall(673);
			base.Store(proc, 0);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Deserialize a serialized SVM-based OCR classifier.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="serializedItemHandle">Handle of the serialized item.</param>
		// Token: 0x06000C4F RID: 3151 RVA: 0x0004DB2C File Offset: 0x0004BD2C
		public void DeserializeOcrClassSvm(HSerializedItem serializedItemHandle)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(674);
			HalconAPI.Store(proc, 0, serializedItemHandle);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(serializedItemHandle);
		}

		/// <summary>
		///   Serialize a SVM-based OCR classifier
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <returns>Handle of the serialized item.</returns>
		// Token: 0x06000C50 RID: 3152 RVA: 0x0004DB80 File Offset: 0x0004BD80
		public HSerializedItem SerializeOcrClassSvm()
		{
			IntPtr proc = HalconAPI.PreCall(675);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HSerializedItem result;
			num = HSerializedItem.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Read a SVM-based OCR classifier from a file.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C51 RID: 3153 RVA: 0x0004DBC8 File Offset: 0x0004BDC8
		public void ReadOcrClassSvm(string fileName)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(676);
			HalconAPI.StoreS(proc, 0, fileName);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Write an OCR classifier to a file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="fileName">File name.</param>
		// Token: 0x06000C52 RID: 3154 RVA: 0x0004DC14 File Offset: 0x0004BE14
		public void WriteOcrClassSvm(string fileName)
		{
			IntPtr proc = HalconAPI.PreCall(677);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, fileName);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the features of a character.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Input character.</param>
		/// <param name="transform">Should the feature vector be transformed with the preprocessing? Default: "true"</param>
		/// <returns>Feature vector of the character.</returns>
		// Token: 0x06000C53 RID: 3155 RVA: 0x0004DC50 File Offset: 0x0004BE50
		public HTuple GetFeaturesOcrClassSvm(HImage character, string transform)
		{
			IntPtr proc = HalconAPI.PreCall(678);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.StoreS(proc, 1, transform);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			return result;
		}

		/// <summary>
		///   Classify a related group of characters with an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <param name="expression">Expression describing the allowed word structure.</param>
		/// <param name="numAlternatives">Number of classes per character considered for the internal word correction. Default: 3</param>
		/// <param name="numCorrections">Maximum number of corrected characters. Default: 2</param>
		/// <param name="word">Word text after classification and correction.</param>
		/// <param name="score">Measure of similarity between corrected word and uncorrected classification results.</param>
		/// <returns>Result of classifying the characters with the SVM.</returns>
		// Token: 0x06000C54 RID: 3156 RVA: 0x0004DCB0 File Offset: 0x0004BEB0
		public HTuple DoOcrWordSvm(HRegion character, HImage image, string expression, int numAlternatives, int numCorrections, out string word, out double score)
		{
			IntPtr proc = HalconAPI.PreCall(679);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.StoreS(proc, 1, expression);
			HalconAPI.StoreI(proc, 2, numAlternatives);
			HalconAPI.StoreI(proc, 3, numCorrections);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			num = HalconAPI.LoadS(proc, 1, num, out word);
			num = HalconAPI.LoadD(proc, 2, num, out score);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify multiple characters with an SVM-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Characters to be recognized.</param>
		/// <param name="image">Gray values of the characters.</param>
		/// <returns>Result of classifying the characters with the SVM.</returns>
		// Token: 0x06000C55 RID: 3157 RVA: 0x0004DD54 File Offset: 0x0004BF54
		public HTuple DoOcrMultiClassSvm(HRegion character, HImage image)
		{
			IntPtr proc = HalconAPI.PreCall(680);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Classify a single character with an SVM-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="character">Character to be recognized.</param>
		/// <param name="image">Gray values of the character.</param>
		/// <param name="num">Number of best classes to determine. Default: 1</param>
		/// <returns>Result of classifying the character with the SVM.</returns>
		// Token: 0x06000C56 RID: 3158 RVA: 0x0004DDB8 File Offset: 0x0004BFB8
		public HTuple DoOcrSingleClassSvm(HRegion character, HImage image, HTuple num)
		{
			IntPtr proc = HalconAPI.PreCall(681);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, character);
			HalconAPI.Store(proc, 2, image);
			HalconAPI.Store(proc, 1, num);
			HalconAPI.InitOCT(proc, 0);
			int num2 = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(num);
			HTuple result;
			num2 = HTuple.LoadNew(proc, 0, num2, out result);
			HalconAPI.PostCall(proc, num2);
			GC.KeepAlive(this);
			GC.KeepAlive(character);
			GC.KeepAlive(image);
			return result;
		}

		/// <summary>
		///   Approximate a trained SVM-based OCR classifier by a reduced SVM.
		///   Instance represents: Original handle of SVM-based OCR-classifier.
		/// </summary>
		/// <param name="method">Type of postprocessing to reduce number of SVs. Default: "bottom_up"</param>
		/// <param name="minRemainingSV">Minimum number of remaining SVs. Default: 2</param>
		/// <param name="maxError">Maximum allowed error of reduction. Default: 0.001</param>
		/// <returns>SVMHandle of reduced OCR classifier.</returns>
		// Token: 0x06000C57 RID: 3159 RVA: 0x0004DE2C File Offset: 0x0004C02C
		public HOCRSvm ReduceOcrClassSvm(string method, int minRemainingSV, double maxError)
		{
			IntPtr proc = HalconAPI.PreCall(682);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, method);
			HalconAPI.StoreI(proc, 2, minRemainingSV);
			HalconAPI.StoreD(proc, 3, maxError);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HOCRSvm result;
			num = HOCRSvm.LoadNew(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Train an OCR classifier with data from a (protected) training file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="epsilon">Stop parameter for training. Default: 0.001</param>
		/// <param name="trainMode">Mode of training. Default: "default"</param>
		// Token: 0x06000C58 RID: 3160 RVA: 0x0004DE8C File Offset: 0x0004C08C
		public void TrainfOcrClassSvmProtected(HTuple trainingFile, HTuple password, double epsilon, HTuple trainMode)
		{
			IntPtr proc = HalconAPI.PreCall(683);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.Store(proc, 2, password);
			HalconAPI.StoreD(proc, 3, epsilon);
			HalconAPI.Store(proc, 4, trainMode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(password);
			HalconAPI.UnpinTuple(trainMode);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Train an OCR classifier with data from a (protected) training file.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="password">Passwords for protected training files.</param>
		/// <param name="epsilon">Stop parameter for training. Default: 0.001</param>
		/// <param name="trainMode">Mode of training. Default: "default"</param>
		// Token: 0x06000C59 RID: 3161 RVA: 0x0004DEF4 File Offset: 0x0004C0F4
		public void TrainfOcrClassSvmProtected(string trainingFile, string password, double epsilon, string trainMode)
		{
			IntPtr proc = HalconAPI.PreCall(683);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, password);
			HalconAPI.StoreD(proc, 3, epsilon);
			HalconAPI.StoreS(proc, 4, trainMode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Train an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="epsilon">Stop parameter for training. Default: 0.001</param>
		/// <param name="trainMode">Mode of training. Default: "default"</param>
		// Token: 0x06000C5A RID: 3162 RVA: 0x0004DF4C File Offset: 0x0004C14C
		public void TrainfOcrClassSvm(HTuple trainingFile, double epsilon, HTuple trainMode)
		{
			IntPtr proc = HalconAPI.PreCall(684);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.StoreD(proc, 2, epsilon);
			HalconAPI.Store(proc, 3, trainMode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HalconAPI.UnpinTuple(trainMode);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Train an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="epsilon">Stop parameter for training. Default: 0.001</param>
		/// <param name="trainMode">Mode of training. Default: "default"</param>
		// Token: 0x06000C5B RID: 3163 RVA: 0x0004DFA4 File Offset: 0x0004C1A4
		public void TrainfOcrClassSvm(string trainingFile, double epsilon, string trainMode)
		{
			IntPtr proc = HalconAPI.PreCall(684);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreD(proc, 2, epsilon);
			HalconAPI.StoreS(proc, 3, trainMode);
			int procResult = HalconAPI.CallProcedure(proc);
			HalconAPI.PostCall(proc, procResult);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Compute the information content of the preprocessed feature vectors of an SVM-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "principal_components"</param>
		/// <param name="cumInformationCont">Cumulative information content of the transformed feature vectors.</param>
		/// <returns>Relative information content of the transformed feature vectors.</returns>
		// Token: 0x06000C5C RID: 3164 RVA: 0x0004DFF0 File Offset: 0x0004C1F0
		public HTuple GetPrepInfoOcrClassSvm(HTuple trainingFile, string preprocessing, out HTuple cumInformationCont)
		{
			IntPtr proc = HalconAPI.PreCall(685);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, preprocessing);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(trainingFile);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cumInformationCont);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Compute the information content of the preprocessed feature vectors of an SVM-based OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="trainingFile">Names of the training files. Default: "ocr.trf"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "principal_components"</param>
		/// <param name="cumInformationCont">Cumulative information content of the transformed feature vectors.</param>
		/// <returns>Relative information content of the transformed feature vectors.</returns>
		// Token: 0x06000C5D RID: 3165 RVA: 0x0004E064 File Offset: 0x0004C264
		public HTuple GetPrepInfoOcrClassSvm(string trainingFile, string preprocessing, out HTuple cumInformationCont)
		{
			IntPtr proc = HalconAPI.PreCall(685);
			base.Store(proc, 0);
			HalconAPI.StoreS(proc, 1, trainingFile);
			HalconAPI.StoreS(proc, 2, preprocessing);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			HTuple result;
			num = HTuple.LoadNew(proc, 0, HTupleType.DOUBLE, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.DOUBLE, num, out cumInformationCont);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the number of support vectors of an OCR classifier.
		///   Instance represents: OCR handle.
		/// </summary>
		/// <param name="numSVPerSVM">Number of SV of each sub-SVM.</param>
		/// <returns>Total number of support vectors.</returns>
		// Token: 0x06000C5E RID: 3166 RVA: 0x0004E0D0 File Offset: 0x0004C2D0
		public int GetSupportVectorNumOcrClassSvm(out HTuple numSVPerSVM)
		{
			IntPtr proc = HalconAPI.PreCall(686);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			int num = HalconAPI.CallProcedure(proc);
			int result;
			num = HalconAPI.LoadI(proc, 0, num, out result);
			num = HTuple.LoadNew(proc, 1, HTupleType.INTEGER, num, out numSVPerSVM);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the index of a support vector from a trained OCR classifier that is based on support vector machines.
		///   Instance represents: OCR handle.
		/// </summary>
		/// <param name="indexSupportVector">Number of stored support vectors.</param>
		/// <returns>Index of the support vector in the training set.</returns>
		// Token: 0x06000C5F RID: 3167 RVA: 0x0004E12C File Offset: 0x0004C32C
		public double GetSupportVectorOcrClassSvm(HTuple indexSupportVector)
		{
			IntPtr proc = HalconAPI.PreCall(687);
			base.Store(proc, 0);
			HalconAPI.Store(proc, 1, indexSupportVector);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(indexSupportVector);
			double result;
			num = HalconAPI.LoadD(proc, 0, num, out result);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
			return result;
		}

		/// <summary>
		///   Return the parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters.</param>
		/// <param name="features">Features to be used for classification.</param>
		/// <param name="characters">Characters of the character set to be read.</param>
		/// <param name="kernelType">The kernel type.</param>
		/// <param name="kernelParam">Additional parameters for the kernel function.</param>
		/// <param name="nu">Regularization constant of the SVM.</param>
		/// <param name="mode">The mode of the SVM.</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors.</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization').</param>
		// Token: 0x06000C60 RID: 3168 RVA: 0x0004E184 File Offset: 0x0004C384
		public void GetParamsOcrClassSvm(out int widthCharacter, out int heightCharacter, out string interpolation, out HTuple features, out HTuple characters, out string kernelType, out double kernelParam, out double nu, out string mode, out string preprocessing, out int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(688);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			HalconAPI.InitOCT(proc, 10);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out widthCharacter);
			num = HalconAPI.LoadI(proc, 1, num, out heightCharacter);
			num = HalconAPI.LoadS(proc, 2, num, out interpolation);
			num = HTuple.LoadNew(proc, 3, num, out features);
			num = HTuple.LoadNew(proc, 4, num, out characters);
			num = HalconAPI.LoadS(proc, 5, num, out kernelType);
			num = HalconAPI.LoadD(proc, 6, num, out kernelParam);
			num = HalconAPI.LoadD(proc, 7, num, out nu);
			num = HalconAPI.LoadS(proc, 8, num, out mode);
			num = HalconAPI.LoadS(proc, 9, num, out preprocessing);
			num = HalconAPI.LoadI(proc, 10, num, out numComponents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Return the parameters of an OCR classifier.
		///   Instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed.</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters.</param>
		/// <param name="features">Features to be used for classification.</param>
		/// <param name="characters">Characters of the character set to be read.</param>
		/// <param name="kernelType">The kernel type.</param>
		/// <param name="kernelParam">Additional parameters for the kernel function.</param>
		/// <param name="nu">Regularization constant of the SVM.</param>
		/// <param name="mode">The mode of the SVM.</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors.</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization').</param>
		// Token: 0x06000C61 RID: 3169 RVA: 0x0004E28C File Offset: 0x0004C48C
		public void GetParamsOcrClassSvm(out int widthCharacter, out int heightCharacter, out string interpolation, out string features, out HTuple characters, out string kernelType, out double kernelParam, out double nu, out string mode, out string preprocessing, out int numComponents)
		{
			IntPtr proc = HalconAPI.PreCall(688);
			base.Store(proc, 0);
			HalconAPI.InitOCT(proc, 0);
			HalconAPI.InitOCT(proc, 1);
			HalconAPI.InitOCT(proc, 2);
			HalconAPI.InitOCT(proc, 3);
			HalconAPI.InitOCT(proc, 4);
			HalconAPI.InitOCT(proc, 5);
			HalconAPI.InitOCT(proc, 6);
			HalconAPI.InitOCT(proc, 7);
			HalconAPI.InitOCT(proc, 8);
			HalconAPI.InitOCT(proc, 9);
			HalconAPI.InitOCT(proc, 10);
			int num = HalconAPI.CallProcedure(proc);
			num = HalconAPI.LoadI(proc, 0, num, out widthCharacter);
			num = HalconAPI.LoadI(proc, 1, num, out heightCharacter);
			num = HalconAPI.LoadS(proc, 2, num, out interpolation);
			num = HalconAPI.LoadS(proc, 3, num, out features);
			num = HTuple.LoadNew(proc, 4, num, out characters);
			num = HalconAPI.LoadS(proc, 5, num, out kernelType);
			num = HalconAPI.LoadD(proc, 6, num, out kernelParam);
			num = HalconAPI.LoadD(proc, 7, num, out nu);
			num = HalconAPI.LoadS(proc, 8, num, out mode);
			num = HalconAPI.LoadS(proc, 9, num, out preprocessing);
			num = HalconAPI.LoadI(proc, 10, num, out numComponents);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a support vector machine.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="kernelType">The kernel type. Default: "rbf"</param>
		/// <param name="kernelParam">Additional parameter for the kernel function. Default: 0.02</param>
		/// <param name="nu">Regularization constant of the SVM. Default: 0.05</param>
		/// <param name="mode">The mode of the SVM. Default: "one-versus-one"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "normalization"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		// Token: 0x06000C62 RID: 3170 RVA: 0x0004E394 File Offset: 0x0004C594
		public void CreateOcrClassSvm(int widthCharacter, int heightCharacter, string interpolation, HTuple features, HTuple characters, string kernelType, double kernelParam, double nu, string mode, string preprocessing, int numComponents)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(689);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.Store(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreS(proc, 5, kernelType);
			HalconAPI.StoreD(proc, 6, kernelParam);
			HalconAPI.StoreD(proc, 7, nu);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, preprocessing);
			HalconAPI.StoreI(proc, 10, numComponents);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(features);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}

		/// <summary>
		///   Create an OCR classifier using a support vector machine.
		///   Modified instance represents: Handle of the OCR classifier.
		/// </summary>
		/// <param name="widthCharacter">Width of the rectangle to which the gray values of the segmented character are zoomed. Default: 8</param>
		/// <param name="heightCharacter">Height of the rectangle to which the gray values of the segmented character are zoomed. Default: 10</param>
		/// <param name="interpolation">Interpolation mode for the zooming of the characters. Default: "constant"</param>
		/// <param name="features">Features to be used for classification. Default: "default"</param>
		/// <param name="characters">All characters of the character set to be read. Default: ["0","1","2","3","4","5","6","7","8","9"]</param>
		/// <param name="kernelType">The kernel type. Default: "rbf"</param>
		/// <param name="kernelParam">Additional parameter for the kernel function. Default: 0.02</param>
		/// <param name="nu">Regularization constant of the SVM. Default: 0.05</param>
		/// <param name="mode">The mode of the SVM. Default: "one-versus-one"</param>
		/// <param name="preprocessing">Type of preprocessing used to transform the feature vectors. Default: "normalization"</param>
		/// <param name="numComponents">Preprocessing parameter: Number of transformed features (ignored for Preprocessing $=$ 'none' and Preprocessing $=$ 'normalization'). Default: 10</param>
		// Token: 0x06000C63 RID: 3171 RVA: 0x0004E448 File Offset: 0x0004C648
		public void CreateOcrClassSvm(int widthCharacter, int heightCharacter, string interpolation, string features, HTuple characters, string kernelType, double kernelParam, double nu, string mode, string preprocessing, int numComponents)
		{
			this.Dispose();
			IntPtr proc = HalconAPI.PreCall(689);
			HalconAPI.StoreI(proc, 0, widthCharacter);
			HalconAPI.StoreI(proc, 1, heightCharacter);
			HalconAPI.StoreS(proc, 2, interpolation);
			HalconAPI.StoreS(proc, 3, features);
			HalconAPI.Store(proc, 4, characters);
			HalconAPI.StoreS(proc, 5, kernelType);
			HalconAPI.StoreD(proc, 6, kernelParam);
			HalconAPI.StoreD(proc, 7, nu);
			HalconAPI.StoreS(proc, 8, mode);
			HalconAPI.StoreS(proc, 9, preprocessing);
			HalconAPI.StoreI(proc, 10, numComponents);
			HalconAPI.InitOCT(proc, 0);
			int num = HalconAPI.CallProcedure(proc);
			HalconAPI.UnpinTuple(characters);
			num = base.Load(proc, 0, num);
			HalconAPI.PostCall(proc, num);
			GC.KeepAlive(this);
		}
	}
}
